#include <variant>
#include <unordered_map>
#include <cstring>
#include <cstdio>
#include <new>
#include <memory>
#include <functional>
#include <cstdlib>

// 类型ID定义
enum TypeId {
    TYPE_INVALID = -1,
    TYPE_INT = 0,
    TYPE_FLOAT = 1,
    TYPE_DOUBLE = 2,
    TYPE_STR = 3,
    TYPE_CUSTOM_BASE = 100
};

struct CustomTypeOps {
    size_t size;
    void (*copy)(const void* src, void* dest);
    void (*destroy)(void* data);
};

static std::unordered_map<TypeId, CustomTypeOps> g_type_registry;
static int g_next_custom_type = TYPE_CUSTOM_BASE;

extern "C" TypeId cvariant_register_custom_type(size_t size, 
                                              void (*copy)(const void*, void*),
                                              void (*destroy)(void*)) {
    TypeId id = static_cast<TypeId>(g_next_custom_type++);
    g_type_registry[id] = {size, copy, destroy};
    return id;
}

// 变体数据存储（字符串使用char*并手动管理内存）
using VariantData = std::variant<
    int,
    float,
    double,
    char*,  // 改为char*以存储动态分配的字符串
    std::unique_ptr<void, std::function<void(void*)>>
>;

typedef struct CVariant {
    VariantData data;
    TypeId type_id;
} CVariant;

static const CustomTypeOps* get_custom_ops(TypeId id) {
    auto it = g_type_registry.find(id);
    return (it != g_type_registry.end()) ? &it->second : nullptr;
}

extern "C" {
    CVariant* cvariant_create() {
        try {
            return new CVariant{{}, TYPE_INVALID};
        } catch (const std::bad_alloc&) {
            return nullptr;
        }
    }

    void cvariant_destroy(CVariant* var) {
        if (!var) return;
        
        // 关键修复：释放字符串内存
        if (var->type_id == TYPE_STR) {
            if (std::holds_alternative<char*>(var->data)) {
                char* str = std::get<char*>(var->data);
                free(str);  // 释放动态分配的字符串
            }
        }
        delete var;
    }

    void cvariant_set_int(CVariant* var, int value) {
        if (var) {
            // 清理原有字符串
            if (var->type_id == TYPE_STR && std::holds_alternative<char*>(var->data)) {
                free(std::get<char*>(var->data));
            }
            var->data = value;
            var->type_id = TYPE_INT;
        }
    }

    void cvariant_set_float(CVariant* var, float value) {
        if (var) {
            // 清理原有字符串
            if (var->type_id == TYPE_STR && std::holds_alternative<char*>(var->data)) {
                free(std::get<char*>(var->data));
            }
            var->data = value;
            var->type_id = TYPE_FLOAT;
        }
    }

    void cvariant_set_double(CVariant* var, double value) {
        if (var) {
            // 清理原有字符串
            if (var->type_id == TYPE_STR && std::holds_alternative<char*>(var->data)) {
                free(std::get<char*>(var->data));
            }
            var->data = value;
            var->type_id = TYPE_DOUBLE;
        }
    }

    // 关键修复：字符串存储改为动态分配
    void cvariant_set_str(CVariant* var, const char* value) {
        if (var) {
            // 先释放原有字符串
            if (var->type_id == TYPE_STR && std::holds_alternative<char*>(var->data)) {
                free(std::get<char*>(var->data));
            }
            
            // 复制字符串并存储
            if (value) {
                char* str = (char*)malloc(strlen(value) + 1);
                if (str) {
                    strcpy(str, value);
                    var->data = str;
                    var->type_id = TYPE_STR;
                    return;
                }
            }
            // 处理空字符串
            var->data = (char*)nullptr;
            var->type_id = TYPE_STR;
        }
    }

    int cvariant_set_custom(CVariant* var, TypeId type_id, const void* data) {
        if (!var || !data || type_id < TYPE_CUSTOM_BASE) return -1;
        
        // 清理原有字符串
        if (var->type_id == TYPE_STR && std::holds_alternative<char*>(var->data)) {
            free(std::get<char*>(var->data));
        }
        
        const auto* ops = get_custom_ops(type_id);
        if (!ops) return -1;

        void* storage = malloc(ops->size);
        if (!storage) return -1;
        ops->copy(data, storage);

        var->data = std::unique_ptr<void, std::function<void(void*)>>(
            storage,
            [type_id](void* ptr) {
                const auto* ops = get_custom_ops(type_id);
                if (ops) ops->destroy(ptr);
                free(ptr);
            }
        );
        var->type_id = type_id;
        return 0;
    }

    TypeId cvariant_get_type(const CVariant* var) {
        return var ? var->type_id : TYPE_INVALID;
    }

    int cvariant_get_int(const CVariant* var) {
        if (var && var->type_id == TYPE_INT && std::holds_alternative<int>(var->data)) {
            return std::get<int>(var->data);
        }
        fprintf(stderr, "cvariant: 类型错误（预期int）\n");
        return 0;
    }

    float cvariant_get_float(const CVariant* var) {
        if (var && var->type_id == TYPE_FLOAT && std::holds_alternative<float>(var->data)) {
            return std::get<float>(var->data);
        }
        fprintf(stderr, "cvariant: 类型错误（预期float）\n");
        return 0.0f;
    }

    double cvariant_get_double(const CVariant* var) {
        if (var && var->type_id == TYPE_DOUBLE && std::holds_alternative<double>(var->data)) {
            return std::get<double>(var->data);
        }
        fprintf(stderr, "cvariant: 类型错误（预期double）\n");
        return 0.0;
    }

    const char* cvariant_get_str(const CVariant* var) {
        if (var && var->type_id == TYPE_STR && std::holds_alternative<char*>(var->data)) {
            return std::get<char*>(var->data);
        }
        fprintf(stderr, "cvariant: 类型错误（预期字符串）\n");
        return nullptr;
    }

    int cvariant_get_custom(const CVariant* var, void* dest) {
        if (!var || !dest || var->type_id < TYPE_CUSTOM_BASE) return -1;
        
        const auto* ops = get_custom_ops(var->type_id);
        if (!ops) return -1;

        if (std::holds_alternative<std::unique_ptr<void, std::function<void(void*)>>>(var->data)) {
            const void* src = std::get<std::unique_ptr<void, std::function<void(void*)>>>(var->data).get();
            ops->copy(src, dest);
            return 0;
        }
        return -1;
    }
}

#if 0
#include <variant>
#include <unordered_map>
#include <cstring>
#include <cstdio>
#include <new>
#include <memory>
#include <functional>  // 用于std::function（删除器）
#include <cstdlib>     // 用于malloc和free

// 类型ID定义（内置类型+自定义类型）
enum TypeId {
    TYPE_INVALID = -1,
    TYPE_INT = 0,
    TYPE_FLOAT = 1,
    TYPE_DOUBLE = 2,
    TYPE_STR = 3,
    TYPE_CUSTOM_BASE = 100  // 自定义类型ID起始值
};

// 自定义类型的操作接口
struct CustomTypeOps {
    size_t size;  // 类型大小
    void (*copy)(const void* src, void* dest);  // 复制函数
    void (*destroy)(void* data);  // 销毁函数
};

// 全局类型注册表
static std::unordered_map<TypeId, CustomTypeOps> g_type_registry;
static int g_next_custom_type = TYPE_CUSTOM_BASE;  // 用int而非TypeId，支持自增

// 注册自定义类型（返回类型ID）
extern "C" TypeId cvariant_register_custom_type(size_t size, 
                                              void (*copy)(const void*, void*),
                                              void (*destroy)(void*)) {
    TypeId id = static_cast<TypeId>(g_next_custom_type++);  // 修复自增问题
    g_type_registry[id] = {size, copy, destroy};
    return id;
}

// 变体数据存储（自定义类型使用std::function作为删除器，支持捕获lambda）
using VariantData = std::variant<
    int,
    float,
    double,
    const char*,
    std::unique_ptr<void, std::function<void(void*)>>  // 修复删除器类型
>;

// C接口的不透明结构体
typedef struct CVariant {
    VariantData data;
    TypeId type_id;  // 当前存储的类型ID
} CVariant;

// 获取自定义类型操作
static const CustomTypeOps* get_custom_ops(TypeId id) {
    auto it = g_type_registry.find(id);
    return (it != g_type_registry.end()) ? &it->second : nullptr;
}

// 导出C接口
extern "C" {
    // 创建变体对象
    CVariant* cvariant_create() {
        try {
            return new CVariant{{}, TYPE_INVALID};
        } catch (const std::bad_alloc&) {
            return nullptr;
        }
    }

    // 销毁变体对象
    void cvariant_destroy(CVariant* var) {
        if (!var) return;
        delete var;  // unique_ptr会自动调用删除器清理自定义类型
    }

    // 设置内置类型：int
    void cvariant_set_int(CVariant* var, int value) {
        if (var) {
            var->data = value;
            var->type_id = TYPE_INT;
        }
    }

    // 设置内置类型：float
    void cvariant_set_float(CVariant* var, float value) {
        if (var) {
            var->data = value;
            var->type_id = TYPE_FLOAT;
        }
    }

    // 设置内置类型：double
    void cvariant_set_double(CVariant* var, double value) {
        if (var) {
            var->data = value;
            var->type_id = TYPE_DOUBLE;
        }
    }

    // 设置内置类型：字符串
    void cvariant_set_str(CVariant* var, const char* value) {
        if (var) {
            var->data = value;
            var->type_id = TYPE_STR;
        }
    }

    // 设置自定义类型（修复unique_ptr构造问题）
    int cvariant_set_custom(CVariant* var, TypeId type_id, const void* data) {
        if (!var || !data || type_id < TYPE_CUSTOM_BASE) return -1;
        
        const auto* ops = get_custom_ops(type_id);
        if (!ops) return -1;

        // 分配内存并复制数据
        void* storage = malloc(ops->size);
        if (!storage) return -1;
        ops->copy(data, storage);

        // 存储数据（使用std::function删除器，支持捕获type_id）
        var->data = std::unique_ptr<void, std::function<void(void*)>>(
            storage,
            [type_id](void* ptr) {  // 捕获type_id的lambda
                const auto* ops = get_custom_ops(type_id);
                if (ops) ops->destroy(ptr);  // 调用自定义销毁函数
                free(ptr);  // 释放malloc的内存
            }
        );
        var->type_id = type_id;
        return 0;
    }

    // 获取当前类型ID
    TypeId cvariant_get_type(const CVariant* var) {
        return var ? var->type_id : TYPE_INVALID;
    }

    // 获取内置类型值
    int cvariant_get_int(const CVariant* var) {
        if (var && var->type_id == TYPE_INT && std::holds_alternative<int>(var->data)) {
            return std::get<int>(var->data);
        }
        fprintf(stderr, "cvariant: 类型错误（预期int）\n");
        return 0;
    }

    float cvariant_get_float(const CVariant* var) {
        if (var && var->type_id == TYPE_FLOAT && std::holds_alternative<float>(var->data)) {
            return std::get<float>(var->data);
        }
        fprintf(stderr, "cvariant: 类型错误（预期float）\n");
        return 0.0f;
    }

    double cvariant_get_double(const CVariant* var) {
        if (var && var->type_id == TYPE_DOUBLE && std::holds_alternative<double>(var->data)) {
            return std::get<double>(var->data);
        }
        fprintf(stderr, "cvariant: 类型错误（预期double）\n");
        return 0.0;
    }

    const char* cvariant_get_str(const CVariant* var) {
        if (var && var->type_id == TYPE_STR && std::holds_alternative<const char*>(var->data)) {
            return std::get<const char*>(var->data);
        }
        fprintf(stderr, "cvariant: 类型错误（预期字符串）\n");
        return nullptr;
    }

    // 获取自定义类型数据
    int cvariant_get_custom(const CVariant* var, void* dest) {
        if (!var || !dest || var->type_id < TYPE_CUSTOM_BASE) return -1;
        
        const auto* ops = get_custom_ops(var->type_id);
        if (!ops) return -1;

        if (std::holds_alternative<std::unique_ptr<void, std::function<void(void*)>>>(var->data)) {
            const void* src = std::get<std::unique_ptr<void, std::function<void(void*)>>>(var->data).get();
            ops->copy(src, dest);
            return 0;
        }
        return -1;
    }
}
#endif